home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / cli / mx2src.arc / ATOMIC.DEF < prev    next >
Encoding:
Modula Definition  |  1989-01-05  |  14.3 KB  |  305 lines
  1. DEFINITION MODULE ATOMIC;
  2.  
  3. (*              Copyright 1987,1988 fred brooks LogicTek        *)
  4. (*                                                              *)
  5. (*                                                              *)
  6. (*   First Release                      12/8/87-FGB             *)
  7. (* Added variable parm to StartProcess to pass info to process  *)
  8. (* in currentprocess.gemsave[15]        1/1/88-FGB              *)
  9. (*                                                              *)
  10. (* Remove monitor priority. Each routine the switches processes *)
  11. (* must be protected from all interrupts by the IntEnd and      *)
  12. (* IntBegin calls. If this is not done correctly the system     *)
  13. (* system will bomb.                    4/4/88-FGB              *)
  14. (*                                                              *)
  15.  
  16. FROM    SYSTEM  IMPORT  ADDRESS,BYTE;
  17. FROM    NEWSYS  IMPORT  PROCESS;
  18. FROM    Strings IMPORT  String;
  19.  
  20. CONST   MAGIC            =       22261; (* somebodys b-day *)
  21.         buflength        =       1024;
  22.         OTOS             =       LONGCARD(602CH); (* Old rom TOS *)
  23.         MTOS             =       LONGCARD(87CEH); (* New rom MEGA TOS *)
  24.         OLDDATE          =       11201985H;
  25.         NEWDATE          =       04221987H;
  26.         VERSION          =       "  MX2 V2.3.0"; (* mx2 version number *)
  27. TYPE
  28.         Gvectype        =       POINTER TO ADDRESS;
  29.         buffer  =       ARRAY [0..buflength] OF BYTE;
  30.         PIPE    =       RECORD
  31.                 pipename:       String;
  32.                 buf     :       buffer;
  33.                 bufsize :       CARDINAL;
  34.                 bufhead :       CARDINAL;
  35.                 buftail :       CARDINAL;
  36.                 cnt     :       CARDINAL;
  37.         END;
  38.         pipeptr =       POINTER TO PIPE;
  39. (*      these devices are defined for use with the MX2 port command
  40.         dev0 thru dev7 are user defineable device drivers. By loading
  41.         the addresses of the correct procedures into the DeviceTable for
  42.         in, out and status custom devices may be defined.
  43.         DeviceTable[dev0].bconstat:=Mybconstat;
  44.         DeviceTable[dev0].bcostat:=Mybcostat;
  45.         DeviceTable[dev0].bconin:=Mybconin;
  46.         DeviceTable[dev0].bconout:=Mybconout;
  47.         Will setup dev0 for use with the port command.
  48.  
  49.         sys port 4 -0 -0
  50.         will cause the process with the PID of 4 to use dev0
  51. *)
  52.         devicetype =    (printer,aux,con,midi,null,dev0,dev1,dev2,dev3,
  53.                          dev4,dev5,dev6,dev7);
  54.         devstattype     =       PROCEDURE(): BOOLEAN;
  55.         devintype       =       PROCEDURE(): LONGCARD;
  56.         devouttype      =       PROCEDURE(CHAR);
  57.  
  58.         devblocktype    =       RECORD
  59.                 bconstat        :       devstattype;
  60.                 bcostat         :       devstattype;
  61.                 bconin          :       devintype;
  62.                 bconout         :       devouttype;
  63.         END;
  64.         devtabletype    =       ARRAY [ORD(dev0)..ORD(dev7)] OF devblocktype;
  65.  
  66. TYPE            SIGNAL          =       POINTER TO ProcessDescriptor;
  67.                 GEMTYPE         =       ARRAY [0..0FFH] OF ADDRESS;
  68.                 pipetype        =       ARRAY [0..31] OF pipeptr;
  69.         (* pipe names starting with mx2 or MX2 are reserved by the
  70.            system *)
  71. (* This is the control record for all system process. Variable
  72.    "currentprocess" points to the currently running process. The ready
  73.    queue is implemented as a linked list round robin. *)
  74.  
  75. (* The gemsave array contains important system vectors that are switched
  76.    with every process. This allows programs to intercept trap vectors
  77.    such as the GEMDOS TRAP 1 and still to allow the other programs
  78.    to run correctly.       current vectors saved are
  79.                            gemsave[0]      gem workspace pointer
  80.                            gemsave[1]      LINEA   VECTOR    28H
  81.                            gemsave[2]      GEMDOS  TRAP 1    84H
  82.                            gemsave[3]      GSX,GEM TRAP 2    88H
  83.                            gemsave[4]      BIOS    TRAP 13   B4H
  84.                            gemsave[5]      XBIOS   TRAP 14   B8H
  85.                            gemsave[6]      linef   VECTOR    2CH
  86.                            gemsave[7]      level2  VECTOR    68H
  87.                            gemsave[8]      level4  VECTOR    70H
  88.                            gemsave[9]      _shell_p         4F6H
  89.                            gemsave[11]     wait value (* V2.2.0 *)
  90.                            gemsave[12]     wait mask  (* V2.2.0 *)
  91.                            gemsave[13]     sleep timer variable
  92.                            gemsave[14]     timer flag variable
  93.                            gemsave[15]     init parameter for process
  94.  
  95.                            misc[0]         priority work variable
  96. *)
  97.  
  98.         ProcessDescriptor =
  99.                RECORD
  100.                         name    :       String;   (* process name *)
  101.                         pid     :       INTEGER;  (* process id   *)
  102.                         cor     :       PROCESS;  (* process coroutine *)
  103.                         pc      :       ADDRESS;  (* process PC *)
  104.                         sr      :       CARDINAL; (* process SR *)
  105.                         ssp     :       ADDRESS;  (* process super SR *)
  106.                         biosval :       ADDRESS;  (* bios call save ptr *)
  107.                         retval  :       ADDRESS;
  108.                         biosave :       ARRAY [0..225] OF CARDINAL;
  109.                         gemsave :       ARRAY [0..15]  OF ADDRESS; 
  110.                         termvec :       ADDRESS;
  111.                         wsp     :       ADDRESS;  (* process work space *)
  112.                         wspsize :       LONGCARD; (* size of work space *)
  113.                         next    :       SIGNAL;   (* ptr to next process *)
  114.                         ppid    :       INTEGER;  (* parent id *)
  115.                         tmpcor  :       PROCESS;  (* cor save variable *)
  116.                         ready   :       BOOLEAN;  (* process run flag *)
  117.                         active  :       BOOLEAN;  (* process alive flag *)
  118.                         intflag :       BOOLEAN;  (* process switched *)
  119.                         date    :       CARDINAL; (* date started *)
  120.                         time    :       CARDINAL; (* time started *)
  121.                         tick    :       LONGCARD; (* total 200hz clocks *)
  122.                         slice   :       LONGCARD; (* restart time 200hz *)
  123.                         pri     :       INTEGER;  (* set length of run *)
  124.                         flags   :       ARRAY [0..2] OF LONGCARD; (* var *)
  125. (* flags[0] is default drive of process that called the kernel
  126.    flags[1] is address of process to be added to ready list of kernel
  127.    flags[2] is size of process stack or workspace
  128. *)
  129.                         ipname  :       String;   (* program name *)
  130.                         iptail  :       String;   (* program command *)
  131.                       ipenvstr  :       String;   (* program env string *)
  132.                         return  :       INTEGER;  (* function return *)
  133.                         errno   :       INTEGER;  (* error number *)
  134.                         bpsave  :       GEMTYPE;  (* save for gemdos *)
  135.                         Iport   :       devicetype;
  136.                         Oport   :       devicetype;
  137.                         waitloc :       POINTER TO LONGCARD; (* V2.2.0 *)
  138.                         misc    :       ARRAY [0..8] OF INTEGER;
  139.                END;
  140.  
  141. (* Vector 144H points to variable that contains this record *)
  142. (* look at SYS.MOD for an example of use of these variables *)
  143.  
  144.      sysrequesttype =
  145.                RECORD
  146.                   req         : BOOLEAN;
  147.                   pid         : INTEGER;
  148.                   magic       : LONGCARD;
  149.                END;
  150.  
  151.      spinttype =
  152.                RECORD
  153.                   proc        : PROC;
  154.                   pid         : INTEGER;
  155.                   data        : ADDRESS;
  156.                END;
  157.  
  158.      StartProcesstype           = PROCEDURE(VAR PROC,VAR LONGCARD,
  159.                                             VAR INTEGER,VAR String,
  160.                                             VAR ADDRESS);
  161.      SwapProcesstype            = PROCEDURE;
  162.      TermProcesstype            = PROCEDURE(VAR INTEGER);
  163.      NextPidtype                = PROCEDURE(): INTEGER;
  164.      SleepProcesstype           = PROCEDURE(VAR INTEGER);
  165.      WakeupProcesstype          = PROCEDURE(VAR INTEGER);
  166.      ChangeProcessPrioritytype  = PROCEDURE(VAR INTEGER,VAR INTEGER);
  167.      MultiBegintype             = PROCEDURE;
  168.      MultiEndtype               = PROCEDURE;
  169.      DozeProcesstype            = PROCEDURE(VAR INTEGER,VAR LONGCARD);
  170.      WaitProcesstype            = PROCEDURE(VAR INTEGER,VAR ADDRESS,
  171.                                             VAR LONGCARD, VAR LONGCARD,
  172.                                             VAR LONGCARD);
  173.  
  174.         sysvariable =
  175.                RECORD
  176.                   currentprocess  : POINTER TO SIGNAL;
  177.                   MULTI           : POINTER TO BOOLEAN;
  178.                   slicebegin      : POINTER TO LONGCARD;
  179.                   contextswitch   : POINTER TO LONGCARD;
  180.                   command         : POINTER TO String;
  181.                   request         : POINTER TO sysrequesttype;
  182.                   CRON            : POINTER TO PROC;
  183.                   spintenable     : POINTER TO BITSET;
  184.                   spintmask       : POINTER TO BITSET;
  185.                   spint           : POINTER TO ARRAY [0..15] OF spinttype;
  186.                   bpsave          : POINTER TO GEMTYPE;
  187.                   pipes           : POINTER TO pipetype;
  188.                   sysmemsize      : POINTER TO LONGCARD;
  189.                   gemsaveGvec     : POINTER TO Gvectype;
  190.                   StartProcess    : StartProcesstype;
  191.                   SwapProcess     : SwapProcesstype;
  192.                   TermProcess     : TermProcesstype;
  193.                   NextPid         : NextPidtype;
  194.                   SleepProcess    : SleepProcesstype;
  195.                   WakeupProcess   : WakeupProcesstype;
  196.                   ChangeProcessPriority : ChangeProcessPrioritytype;
  197.                   MultiBegin      : MultiBegintype;
  198.                   MultiEnd        : MultiEndtype;
  199.                   DozeProcess     : DozeProcesstype;
  200.                   WaitProcess     : WaitProcesstype;
  201.                   CronActive      : POINTER TO BOOLEAN;
  202.                   DeviceTable     : POINTER TO devtabletype;
  203.                END;
  204.  
  205. VAR             currentprocess               : SIGNAL;
  206.                 MULTI                        : BOOLEAN;
  207.                 slicebegin                   : LONGCARD;
  208.                 contextswitch                : LONGCARD;
  209.                 command                      : String;
  210.                 request                      : sysrequesttype;
  211.                 CRON                         : PROC;
  212.                 spintenable                  : BITSET;
  213.                 spintmask                    : BITSET;
  214.                 spint                        : ARRAY [0..15] OF spinttype;
  215.                 bpsave                       : GEMTYPE;
  216.                 pipes                        : pipetype;
  217.                 sysmemsize                   : LONGCARD;
  218.                 ROMDATE [0fc0018H]           : LONGCARD;
  219.                 gemsaveGvec                  : Gvectype;
  220.                 CronActive                   : BOOLEAN;
  221.                 DeviceTable                  : devtabletype;
  222.                 (* A spint is a software interrupt. It is called by
  223.                    setting it's bit in the spint enable mask. Spints
  224.                    0-3 are reserved by the system   *)
  225.                 (* The CRON procedure variable is here to put your
  226.                    own procedure into the init scheduler in MX2 this
  227.                    procedure will be run every 30 seconds. It is setup to
  228.                    the dummy procedure at first. to setup your own
  229.                    get sysvar then (sysvar.CRON:='your procedure') *)
  230.  
  231. (* start the master context switch interrupt and setup system variables *)
  232. PROCEDURE Initsked;
  233.  
  234. (* setup kernal to begin the system startup setup all buffers and 
  235.    procedures for MX2 *)
  236. PROCEDURE InitProcesses;
  237.  
  238. (* shutdown kernal and restore to normal gem state *)
  239. (* this currently does not work *)
  240. PROCEDURE EndProcesses;
  241.  
  242. (* create a process for the MX2 system, place in the scheduler ready
  243.    list, start new process *)
  244. PROCEDURE StartProcess(VAR P: PROC; 
  245.                        VAR n: LONGCARD; 
  246.                        VAR priority: INTEGER; 
  247.                        VAR pn: String;
  248.                        VAR parm: ADDRESS);
  249.                        (* parm is the init parameter to be placed in
  250.                           gemsave[15]  *)
  251.  
  252. (* store the currentprocess and switch to next process in ready list *)
  253. PROCEDURE SwapProcess;
  254.  
  255. (* end process and remove it from the ready list, free memory used by
  256.    process *)
  257. PROCEDURE TermProcess(VAR id: INTEGER);
  258.  
  259. (* return the next pid the system will use for a new process *)
  260. PROCEDURE NextPid(): INTEGER;
  261.  
  262. (* tell scheduler not to run this process but keep in memory *)
  263. PROCEDURE SleepProcess(VAR id: INTEGER);
  264.  
  265. (* tell scheduler to sleep for msec 1000th of a second  *)
  266. PROCEDURE DozeProcess(VAR id: INTEGER; VAR msec: LONGCARD);
  267.  
  268. (* Sleep process until the contents of 'loc' equals 'value AND mask'.
  269. msec is the timeout value in milliseconds if set the 0 it waits forever *)
  270. PROCEDURE WaitProcess(VAR id: INTEGER; VAR loc: ADDRESS;
  271.                       VAR value,mask,msec: LONGCARD);
  272.  
  273. (* tell scheduler to start running this process again if it was sleeping
  274.    before *)
  275. PROCEDURE WakeupProcess(VAR id: INTEGER);
  276.  
  277. (* V0.7 change process priority *)
  278. PROCEDURE ChangeProcessPriority(VAR id: INTEGER; VAR pri: INTEGER);
  279.  
  280. (* turn on the scheduler interrupt, and start normal process switching *)
  281. PROCEDURE MultiBegin;
  282.  
  283. (* turn off the scheduler interrupt, used to stop process switching in
  284.    section of code that should not be swapped out *)
  285. PROCEDURE MultiEnd;
  286.  
  287. (* check if flag is TRUE and lock out other process from changing it's
  288.    state until procedure is over *)
  289. PROCEDURE CheckFlag(VAR flag: BOOLEAN): BOOLEAN;
  290.  
  291. (* set flag to TRUE and lock out other process from changing it's
  292.    state until procedure is over *)
  293. PROCEDURE SetFlag(VAR flag: BOOLEAN);
  294.  
  295. (* set flag to FALSE and lock out other process from changing it's
  296.    state until procedure is over *)
  297. PROCEDURE ResetFlag(VAR flag: BOOLEAN);
  298.  
  299. (* check if flag is TRUE then set flag to FALSE while locking out other 
  300.    process from changing it's state until procedure is over *)
  301. PROCEDURE CheckResetFlag(VAR flag: BOOLEAN): BOOLEAN;
  302.  
  303. END             ATOMIC.
  304.  
  305.